// utils/system.js - 系统相关工具

/**
 * 获取系统信息
 * @returns {Object} 系统信息对象
 */
export const getSystemInfo = () => {
  try {
    return uni.getSystemInfoSync();
  } catch (error) {
    console.error('获取系统信息失败:', error);
    return {};
  }
};

/**
 * 判断是否是iOS设备
 * @returns {boolean} 是否是iOS设备
 */
export const isIOS = () => {
  try {
    const systemInfo = uni.getSystemInfoSync();
    return systemInfo.platform === 'ios';
  } catch (error) {
    console.error('判断iOS设备失败:', error);
    return false;
  }
};

/**
 * 判断是否是Android设备
 * @returns {boolean} 是否是Android设备
 */
export const isAndroid = () => {
  try {
    const systemInfo = uni.getSystemInfoSync();
    return systemInfo.platform === 'android';
  } catch (error) {
    console.error('判断Android设备失败:', error);
    return false;
  }
};

/**
 * 获取当前网络类型
 * @returns {Promise<string>} 网络类型
 */
export const getNetworkType = () => {
  return new Promise((resolve, reject) => {
    uni.getNetworkType({
      success: (res) => {
        resolve(res.networkType);
      },
      fail: (error) => {
        console.error('获取网络类型失败:', error);
        reject(error);
      }
    });
  });
};

/**
 * 监听网络状态变化
 * @param {Function} callback 回调函数
 */
export const onNetworkStatusChange = (callback) => {
  uni.onNetworkStatusChange((res) => {
    callback(res);
  });
};

/**
 * 获取屏幕亮度
 * @returns {Promise<number>} 屏幕亮度值，范围0~1
 */
export const getScreenBrightness = () => {
  return new Promise((resolve, reject) => {
    uni.getScreenBrightness({
      success: (res) => {
        resolve(res.value);
      },
      fail: (error) => {
        console.error('获取屏幕亮度失败:', error);
        reject(error);
      }
    });
  });
};

/**
 * 设置屏幕亮度
 * @param {number} value 屏幕亮度值，范围0~1
 * @returns {Promise<void>}
 */
export const setScreenBrightness = (value) => {
  return new Promise((resolve, reject) => {
    uni.setScreenBrightness({
      value,
      success: () => {
        resolve();
      },
      fail: (error) => {
        console.error('设置屏幕亮度失败:', error);
        reject(error);
      }
    });
  });
};

/**
 * 获取设备电量信息
 * @returns {Promise<Object>} 电量信息对象
 */
export const getBatteryInfo = () => {
  return new Promise((resolve) => {
    // 优先使用异步方法
    if (uni.getBatteryInfo) {
      uni.getBatteryInfo({
        success: (res) => {
          resolve(res);
        },
        fail: () => {
          // 如果异步方法失败，尝试同步方法
          try {
            if (uni.getBatteryInfoSync) {
              const batteryInfo = uni.getBatteryInfoSync();
              resolve(batteryInfo);
            } else {
              resolve({ level: 100, isCharging: false });
            }
          } catch (e) {
            resolve({ level: 100, isCharging: false });
          }
        }
      });
    } else if (uni.getBatteryInfoSync) {
      // 如果只有同步方法
      try {
        const batteryInfo = uni.getBatteryInfoSync();
        resolve(batteryInfo);
      } catch (e) {
        resolve({ level: 100, isCharging: false });
      }
    } else {
      // 如果都不支持
      resolve({ level: 100, isCharging: false });
    }
  });
};

/**
 * 获取应用版本信息
 * @returns {string} 应用版本号
 */
export const getAppVersion = () => {
  // 这里返回配置的版本号，实际项目中可能需要从配置文件或接口获取
  try {
    const systemInfo = uni.getSystemInfoSync();
    return systemInfo.appVersion || process.env.VUE_APP_VERSION || '1.0.0';
  } catch (error) {
    console.error('获取应用版本失败:', error);
    return '1.0.0';
  }
};

/**
 * 检查应用更新（仅小程序有效）
 */
export const checkUpdate = () => {
  // 获取小程序更新管理器
  if (uni.getUpdateManager) {
    const updateManager = uni.getUpdateManager();
    
    // 检查是否有新版本
    updateManager.onCheckForUpdate((res) => {
      if (res.hasUpdate) {
        console.log('有新版本可用');
        
        // 新版本下载完成
        updateManager.onUpdateReady(() => {
          uni.showModal({
            title: '更新提示',
            content: '新版本已经准备好，是否重启应用？',
            success: (res) => {
              if (res.confirm) {
                // 重启应用，应用新版本
                updateManager.applyUpdate();
              }
            }
          });
        });
        
        // 新版本下载失败
        updateManager.onUpdateFailed(() => {
          uni.showModal({
            title: '更新提示',
            content: '新版本下载失败，请检查网络后重试',
            showCancel: false
          });
        });
      }
    });
  }
};

/**
 * 设置剪贴板内容
 * @param {string} data 剪贴板内容
 * @returns {Promise<void>}
 */
export const setClipboardData = (data) => {
  return new Promise((resolve, reject) => {
    uni.setClipboardData({
      data,
      success: () => {
        resolve();
      },
      fail: (error) => {
        console.error('设置剪贴板内容失败:', error);
        reject(error);
      }
    });
  });
};

/**
 * 获取剪贴板内容
 * @returns {Promise<string>} 剪贴板内容
 */
export const getClipboardData = () => {
  return new Promise((resolve, reject) => {
    uni.getClipboardData({
      success: (res) => {
        resolve(res.data);
      },
      fail: (error) => {
        console.error('获取剪贴板内容失败:', error);
        reject(error);
      }
    });
  });
};

/**
 * 检查小程序是否已经更新（仅小程序有效）
 * @returns {boolean} 是否已更新
 */
export const checkAppUpdate = () => {
  try {
    // #ifdef MP
    const updateManager = uni.getUpdateManager();
    updateManager.onCheckForUpdate((res) => {
      return res.hasUpdate;
    });
    // #endif
    return false;
  } catch (error) {
    console.error('检查应用更新失败:', error);
    return false;
  }
};

/**
 * 检查API接口兼容性
 * @param {string} apiName API名称
 * @returns {boolean} 是否支持
 */
export const canIUse = (apiName) => {
  return !!uni.canIUse && uni.canIUse(apiName);
};

/**
 * 获取设备信息
 * @returns {Object} 设备信息对象
 */
export const getDeviceInfo = () => {
  try {
    const systemInfo = uni.getSystemInfoSync();
    return {
      deviceId: systemInfo.deviceId || systemInfo.uuid || `${systemInfo.brand}-${systemInfo.model}-${Date.now()}`,
      brand: systemInfo.brand,
      model: systemInfo.model,
      platform: systemInfo.platform,
      system: systemInfo.system,
      deviceType: getDeviceType(systemInfo),
      deviceOrientation: systemInfo.deviceOrientation || 'portrait',
      screenWidth: systemInfo.screenWidth,
      screenHeight: systemInfo.screenHeight,
      windowWidth: systemInfo.windowWidth,
      windowHeight: systemInfo.windowHeight,
      statusBarHeight: systemInfo.statusBarHeight,
      safeArea: systemInfo.safeArea,
      language: systemInfo.language,
      version: systemInfo.version,
      SDKVersion: systemInfo.SDKVersion
    };
  } catch (error) {
    console.error('获取设备信息失败:', error);
    return {};
  }
};

/**
 * 根据系统信息判断设备类型
 * @param {Object} systemInfo 系统信息
 * @returns {string} 设备类型
 */
const getDeviceType = (systemInfo) => {
  // 根据屏幕尺寸和平台判断设备类型
  const { screenWidth, screenHeight, platform } = systemInfo;
  const maxSize = Math.max(screenWidth, screenHeight);
  
  if (platform === 'ios') {
    if (maxSize >= 1024) return 'iPad';
    return 'iPhone';
  } else if (platform === 'android') {
    if (maxSize >= 1024) return 'tablet';
    return 'phone';
  } else if (platform === 'windows' || platform === 'mac') {
    return 'pc';
  }
  
  return 'unknown';
};

/**
 * 获取状态栏高度
 * @returns {number} 状态栏高度（px）
 */
export const getStatusBarHeight = () => {
  try {
    const systemInfo = uni.getSystemInfoSync();
    return systemInfo.statusBarHeight || 0;
  } catch (error) {
    console.error('获取状态栏高度失败:', error);
    return 0;
  }
};

export default {
  getSystemInfo,
  isIOS,
  isAndroid,
  getNetworkType,
  onNetworkStatusChange,
  getScreenBrightness,
  setScreenBrightness,
  getBatteryInfo,
  getAppVersion,
  checkUpdate,
  setClipboardData,
  getClipboardData,
  checkAppUpdate,
  canIUse,
  getDeviceInfo,
  getStatusBarHeight
};